<style></style>

<div id="dailianwanzi_order_list">
    <blockquote class="layui-elem-quote">
       代练丸子订单列表
    </blockquote>
    
    <!-- 搜索区域 -->
    <div class="layui-form-item" style="margin-bottom: 15px;">
        <div class="layui-input-block">
            <div class="layui-input-inline" style="width: 300px;">
                <input type="text" id="dailianwanzi_searchKeyword" placeholder="请输入订单ID或标题进行搜索" class="layui-input">
            </div>
            <div class="layui-input-inline" style="width: 150px;">
                <select id="dailianwanzi_statusSort" lay-verify="" lay-search>
                    <option value="">全部状态</option>
                    <option value="2">待接单</option>
                    <option value="3">代练中</option>
                    <option value="4">待验收</option>
                    <option value="13">待付款</option>
                    <option value="14">已取消订单</option>
                </select>
            </div>
            <button class="layui-btn" id="dailianwanzi_searchBtn">搜索</button>
            <button class="layui-btn layui-btn-primary" id="dailianwanzi_resetBtn">重置</button>
            <button class="layui-btn layui-btn-warm" id="dailianwanzi_refreshBtn">刷新数据</button>
            <button class="layui-btn layui-btn-danger" id="batchCancelBtn">批量取消订单</button>
            <button class="layui-btn layui-btn-warm" id="batchCheckBtn">自动批量检查订单</button>
        </div>
    </div>
    
 
    
    <table class="layui-table" id="ID-dailianwanzi-order-table"> </table>
</div>

<!-- 自定义操作模板 -->
<script type="text/html" id="dailianwanzi_templet-order-tool">
  <div class="layui-clear-space">
    <a class="layui-btn layui-btn-sm layui-btn-danger cancel-order-btn" lay-event="cancel_order">取消订单</a>
    <span class="layui-btn layui-btn-sm layui-btn-disabled cannot-cancel-btn" style="display: none;">无法取消</span>
  </div>
</script>

<!-- 自动化批量检查控制台日志模态框 -->
<div id="autoCheckConsoleModal" style="display: none;">
    <div id="autoCheckConsoleLog" style="max-height: 400px; overflow-y: auto; background-color: #f5f5f5; padding: 10px; font-family: monospace; font-size: 12px;"></div>
    <div style="margin-top: 15px; text-align: center;">
        <button class="layui-btn layui-btn-danger" id="autoCheckStopButton">停止自动化检查</button>
    </div>
</div>

<script>
    layui.use(['table', 'layer', 'form'], function () {
        var $ = layui.$;
        var table = layui.table;
        var layer = layui.layer;
        var form = layui.form;
        
        // 存储原始订单数据
        var allOrders = [];
        var currentPage = 1;
        var currentPageSize = 10;
        
        // 自动化批量检查相关变量
        var autoCheckInterval = null; // 定时器
        var isAutoCheckRunning = false; // 自动化检查是否运行
        var autoCheckConsoleModalIndex = null; // 控制台模态框索引
        
        /**
         * 渲染订单表格
         * 初始化表格配置并创建表格实例
         */
        var orderTable = table.render({
            "elem": "#ID-dailianwanzi-order-table",
            "title": "代练丸子订单列表",
            "cols": [[
                {type: 'checkbox', fixed: 'left'},
                { "field": "order_id", "title": "订单ID", "width": 200 },
                { "field": "status", "title": "订单状态", "width": 100, "templet": function(d) {
                    // 根据状态码显示对应的状态文本
                    var statusMap = {
                        2: '待接单',
                        3: '代练中',
                        4: '待验收',
                        13: '待付款',
                        14: '已取消订单'
                    };
                    return statusMap[d.status] || '未知状态';
                }},
                { "field": "title", "title": "订单标题", "width": 300 },
                { "field": "gameName", "title": "游戏", "width": 100 },
                { "field": "gameRegionName", "title": "区服", "width": 100 },
                { "field": "gameServerName", "title": "服务器", "width": 100 },
                { "field": "amount", "title": "订单金额", "width": 100, "sort": true },
                { "field": "hour", "title": "时间要求", "width": 100 },
                { "field": "securityDeposit", "title": "保证金", "width": 100, "sort": true },
                { "field": "efficiencyDeposit", "title": "效率金", "width": 100, "sort": true },
                { "field": "Action", "title": "操作", "width": 160, "fixed": "right", "align": "center", "toolbar": "#dailianwanzi_templet-order-tool" },
            ]],
            "data": [], // 初始为空数据
            "page": true, // 使用表格自带的分页
            "limit": currentPageSize,
            "limits": [10, 20, 50], // 可选的每页显示条数
            "cellMinWidth": 80 // 最小单元格宽度
        });
        
        /**
         * 获取订单状态文本
         * @param {number} statusCode - 状态码
         * @returns {string} 状态文本
         */
        function getStatusText(statusCode) {
            var statusMap = {
                2: '待接单',
                3: '代练中',
                4: '待验收',
                13: '待付款',
                14: '已取消订单'
            };
            return statusMap[statusCode] || '未知状态';
        }
        
        /**
         * 加载订单数据
         * @param {number} page - 页码
         * @param {number} pageSize - 每页条数
         */
        function loadOrderData(page, pageSize) {
            // 更新当前页码和每页条数
            currentPage = page || 1;
            currentPageSize = pageSize || currentPageSize;
            
            // 显示加载中
            layer.load();
            
            // 调用订单列表接口，请求所有数据而非分页数据
            axios.get('/api/dailianwanzi/get_my_orders/', {
                params: {
                    page: 1,  // 请求第一页
                    page_size: 100  // 足够大的页码，确保获取所有订单
                }
            })
            .then(function(res) {
                if (res.data.code === 0 && res.data.data) {
                    // 保存原始数据用于搜索
                    allOrders = res.data.data.order_list || [];
                    
                    // 更新总数显示
                    $('#totalCount').text(allOrders.length || 0);
                    
                    // 更新表格数据，应用分页设置
                    orderTable.reload({
                        data: allOrders,
                        limit: currentPageSize,
                        page: currentPage
                    });
                } else {
                    layer.msg('获取订单数据失败：' + (res.data.message || '未知错误'), {icon: 5});
                }
            })
            .catch(function(error) {
                layer.msg('网络错误，无法获取订单数据', {icon: 5});
                console.error('获取订单数据失败：', error);
            })
            .finally(function() {
                // 隐藏加载中
                layer.closeAll('loading');
            });
        }
        
        /**
         * 搜索订单
         * @param {string} keyword - 搜索关键词
         * @param {string} status - 订单状态
         */
        function searchOrders(keyword, status) {
            // 如果没有任何筛选条件，显示全部数据
            if ((!keyword || keyword.trim() === '') && (!status || status === '')) {
                orderTable.reload({
                    data: allOrders,
                    limit: currentPageSize
                });
                return;
            }
            
            // 执行本地搜索和筛选
            var searchResult = allOrders.filter(function(order) {
                // 关键词搜索
                var keywordMatch = true;
                if (keyword && keyword.trim() !== '') {
                    keywordMatch = (
                        (order.order_id && order.order_id.includes(keyword)) ||
                        (order.title && order.title.includes(keyword)) ||
                        (order.gameName && order.gameName.includes(keyword))
                    );
                }
                
                // 状态筛选
                var statusMatch = true;
                if (status && status !== '') {
                    statusMatch = (order.status === parseInt(status));
                }
                
                return keywordMatch && statusMatch;
            });
            
            // 更新表格数据
            orderTable.reload({
                data: searchResult,
                limit: currentPageSize
            });
        }
        
        /**
         * 取消订单
         * @param {string} orderId - 订单ID
         * @param {Function} callback - 回调函数
         */
        function cancelOrder(orderId, callback) {
            // 显示加载中
            layer.load();
            
            // 调用取消订单接口
            axios.get('/api/dailianwanzi/cancel_order/', {
                params: {
                    order_id: orderId
                }
            })
            .then(function(res) {
                // 隐藏加载中
                layer.closeAll('loading');
                
                if (res.data.code === 0) {
                    console.log('取消订单成功：', orderId);
                    if (callback) callback(true, orderId, '成功');
                } else {
                    var errorMsg = '取消订单失败：' + (res.data.message || '未知错误');
                    console.error(errorMsg);
                    if (callback) callback(false, orderId, errorMsg);
                }
            })
            .catch(function(error) {
                // 隐藏加载中
                layer.closeAll('loading');
                
                var errorMsg = '网络错误，取消订单失败：' + error;
                console.error(errorMsg);
                if (callback) callback(false, orderId, errorMsg);
            });
        }
        
        /**
         * 单条订单取消（带确认框）
         * @param {string} orderId - 订单ID
         */
        function confirmCancelOrder(orderId) {
            // 弹出确认框
            layer.confirm('确定要取消此订单吗？', {
                btn: ['确定', '取消'] // 按钮
            }, function() {
                // 显示加载中
                layer.load();
                
                // 调用取消订单接口
                axios.get('/api/dailianwanzi/cancel_order/', {
                    params: {
                        order_id: orderId
                    }
                })
                .then(function(res) {
                    if (res.data.code === 0) {
                        layer.msg('取消订单成功', {icon: 6});
                        // 重新加载数据
                        loadOrderData(currentPage, currentPageSize);
                    } else {
                        layer.msg('取消订单失败：' + (res.data.message || '未知错误'), {icon: 5});
                    }
                })
                .catch(function(error) {
                    layer.msg('网络错误，取消订单失败', {icon: 5});
                    console.error('取消订单失败：', error);
                })
                .finally(function() {
                    // 隐藏加载中
                    layer.closeAll('loading');
                });
            });
        }
        
        // 初始化时加载数据
        loadOrderData();
        
        // 搜索按钮点击事件
        $('#dailianwanzi_searchBtn').on('click', function() {
            var keyword = $('#dailianwanzi_searchKeyword').val();
            var status = $('#dailianwanzi_statusSort').val();
            searchOrders(keyword, status);
        });
        
        // 重置按钮点击事件
        $('#dailianwanzi_resetBtn').on('click', function() {
            $('#dailianwanzi_searchKeyword').val('');
            $('#dailianwanzi_statusSort').val('');
            form.render('select'); // 重新渲染select
            loadOrderData(currentPage, currentPageSize);
        });
        
        // 刷新按钮点击事件
        $('#dailianwanzi_refreshBtn').on('click', function() {
            loadOrderData(currentPage, currentPageSize);
        });
        
        // 每页条数改变事件
        form.on('select(pageSize)', function(data) {
            var newPageSize = parseInt(data.value);
            // 直接应用新的分页大小，不需要重新请求数据
            orderTable.reload({
                limit: newPageSize,
                page: 1  // 重置到第一页
            });
        });
        
        // 回车键触发搜索
        $('#dailianwanzi_searchKeyword').on('keydown', function(e) {
            if (e.keyCode === 13) {
                var keyword = $(this).val();
                var status = $('#dailianwanzi_statusSort').val();
                searchOrders(keyword, status);
            }
        });
        
        // 状态排序选择改变事件
        $('#dailianwanzi_statusSort').on('change', function() {
            var keyword = $('#dailianwanzi_searchKeyword').val();
            var status = $(this).val();
            searchOrders(keyword, status);
        });
        
        // 添加表格事件监听
        table.on('tool(ID-dailianwanzi-order-table)', function(obj) {
            var data = obj.data; // 获得当前行数据
            var layEvent = obj.event; // 获得 lay-event 对应的值
            
            if(layEvent === 'cancel_order'){
                // 订单状态为2（待接单）或13（待付款）时，允许取消订单
                if(data.status === 2 || data.status === 13){
                    // 取消订单
                cancelOrder(data.order_id, function(success, orderId, msg) {
                    if (success) {
                        layer.msg('取消订单成功', {icon: 6});
                        // 重新加载数据
                        loadOrderData(currentPage, currentPageSize);
                    } else {
                        layer.msg(msg, {icon: 5});
                    }
                });
                } else {
                    layer.msg('只有待接单或待付款状态的订单才能取消', {icon: 5});
                }
            }
        });
        
        /**
         * 批量取消订单
         * 实现每3-5秒自动发送一次取消请求的机制
         */
        function batchCancelOrders() {
            // 获取选中的订单
            var checkStatus = table.checkStatus('ID-dailianwanzi-order-table');
            var selectedData = checkStatus.data;
            
            if (selectedData.length === 0) {
                layer.msg('请先选择要取消的订单', {icon: 5});
                return;
            }
            
            // 过滤出符合取消条件的订单（状态为2-待接单或13-待付款）
            var cancelableOrders = selectedData.filter(function(order) {
                return order.status === 2 || order.status === 13;
            });
            
            if (cancelableOrders.length === 0) {
                layer.msg('选中的订单中没有可取消的订单（只有待接单或待付款状态的订单才能取消）', {icon: 5});
                return;
            }
            
            // 弹出确认框
            layer.confirm('确定要批量取消选中的 ' + cancelableOrders.length + ' 个订单吗？', {
                btn: ['确定', '取消'],
                icon: 3,
                title: '批量取消订单确认'
            }, function(index) {
                layer.close(index);
                
                var total = cancelableOrders.length;
                var successCount = 0;
                var failCount = 0;
                var currentIndex = 0;
                var failOrders = [];
                
                // 创建进度条弹窗
                var progressIndex = layer.load(2, {
                    shade: [0.3, '#333'],
                    content: '正在取消订单... 0/' + total,
                    success: function(layero) {
                        layero.find('.layui-layer-content').css('padding', '20px');
                    }
                });
                
                /**
                 * 处理下一个订单
                 */
                function processNextOrder() {
                    if (currentIndex >= cancelableOrders.length) {
                        // 所有订单处理完成
                        layer.close(progressIndex);
                        
                        var resultMsg = '批量取消订单完成！\n成功：' + successCount + ' 个\n失败：' + failCount + ' 个';
                        if (failOrders.length > 0) {
                            resultMsg += '\n失败订单：' + failOrders.join(', ');
                        }
                        
                        layer.alert(resultMsg, {
                            icon: 6,
                            title: '批量取消结果',
                            end: function() {
                                // 弹窗关闭时，关闭所有loading弹层
                                layer.closeAll('loading');
                            }
                        });
                        return;
                    }
                    
                    var order = cancelableOrders[currentIndex];
                    currentIndex++;
                    
                    // 更新进度条
                    layer.load(2, {
                        shade: [0.3, '#333'],
                        content: '正在取消订单... ' + (currentIndex - 1) + '/' + total + '\n当前订单ID：' + order.order_id,
                        success: function(layero) {
                            layero.find('.layui-layer-content').css('padding', '20px');
                        }
                    });
                    layer.close(progressIndex);
                    progressIndex = arguments[0];
                    
                    // 取消订单
                    cancelOrder(order.order_id, function(success, orderId, msg) {
                        if (success) {
                            successCount++;
                        } else {
                            failCount++;
                            failOrders.push(orderId);
                        }
                        
                        // 随机等待3-5秒后处理下一个订单
                        var waitTime = 3000 + Math.random() * 2000; // 3000-5000毫秒
                        console.log('等待 ' + (waitTime/1000).toFixed(1) + ' 秒后处理下一个订单');
                        
                        setTimeout(processNextOrder, waitTime);
                    });
                }
                
                // 开始处理订单
                processNextOrder();
            });
        }
        
        /**
         * 根据子订单编号查询关联订单
         * @param {string} subOrderNo - 子订单编号
         * @returns {Promise} - 返回关联订单信息的Promise
         */
        function getRelatedOrderBySubOrderNo(subOrderNo) {
            // 调用根据子订单编号查询关联订单的API
            return axios.get('/api/order/sub/get_related_order/', {
                params: {
                    'sub_order_no': subOrderNo
                }
            })
            .then(function(res) {
                if (res.data.code === 0 && res.data.data && res.data.data.length > 0) {
                    // 返回第一个关联订单
                    return res.data.data[0];
                } else {
                    return null;
                }
            })
            .catch(function(error) {
                console.error('查询关联订单失败：', error);
                return null;
            });
        }
        
        /**
         * 检查订单是否存在
         * @param {string} orderId - 订单ID
         * @returns {Promise} - 返回检查结果的Promise
         */
        function checkOrderExists(orderId) {
            // 调用检查订单是否存在的API
            return axios.get('/api/dailiantong/check_order_exists/', {
                params: {
                    'order_id': orderId
                }
            })
            .then(function(res) {
                if (res.data.code === 0) {
                    return {exists: true, message: res.data.message};
                } else {
                    return {exists: false, message: res.data.message};
                }
            })
            .catch(function(error) {
                console.error('检查订单失败：', error);
                return {exists: false, message: '网络错误' + (error ? ': ' + error : '')};
            });
        }
        
        /**
         * 向控制台添加日志
         */
        function appendConsoleLog(message) {
            var now = new Date();
            var timeStr = now.getHours().toString().padStart(2, '0') + ':' + 
                          now.getMinutes().toString().padStart(2, '0') + ':' + 
                          now.getSeconds().toString().padStart(2, '0');
            
            var logItem = '[' + timeStr + '] ' + message;
            
            // 添加到控制台，确保每条日志单独一行
            var consoleElement = $('#autoCheckConsoleLog');
            var logElement = $('<div></div>').text(logItem);
            consoleElement.append(logElement);
            
            // 滚动到底部
            consoleElement.scrollTop(consoleElement[0].scrollHeight);
            
            // 同时输出到浏览器控制台
            console.log(logItem);
        }
        
        /**
         * 启动控制台模态框
         */
        function startAutoCheckConsoleModal() {
            if (autoCheckConsoleModalIndex) {
                // 如果模态框已经存在，先关闭
                layer.close(autoCheckConsoleModalIndex);
            }
            
            // 清空控制台内容
            $('#autoCheckConsoleLog').empty();
            
            // 打开新的模态框
            autoCheckConsoleModalIndex = layer.open({
                type: 1,
                title: '自动化批量检查订单控制台',
                content: $('#autoCheckConsoleModal'),
                area: ['800px', '500px'],
                btn: [],
                closeBtn: false, // 不显示关闭按钮，只能通过停止按钮关闭
                shadeClose: false // 点击遮罩层不关闭
            });
            
            // 绑定控制台内的停止按钮事件
            $('#autoCheckStopButton').off('click').on('click', function() {
                stopAutoBatchCheckOrders();
            });
        }
        
        /**
         * 关闭控制台模态框
         */
        function closeAutoCheckConsoleModal() {
            if (autoCheckConsoleModalIndex) {
                layer.close(autoCheckConsoleModalIndex);
                autoCheckConsoleModalIndex = null;
            }
        }
        
        /**
         * 自动化批量检查订单
         * 自动获取状态为2的订单，完成后重新获取数据继续检查
         */
        function autoBatchCheckOrders() {
            // 获取所有订单数据
            appendConsoleLog('正在获取最新订单数据...');
            
            // 调用订单列表接口，获取所有订单
            axios.get('/api/dailianwanzi/get_my_orders/', {
                params: {
                    page: 1,  // 请求第一页
                    page_size: 100  // 足够大的页码，确保获取所有订单
                }
            })
            .then(function(res) {
                if (res.data.code === 0 && res.data.data && res.data.data.order_list) {
                    var allOrders = res.data.data.order_list;
                    appendConsoleLog('成功获取 ' + allOrders.length + ' 条订单数据');
                    
                    // 筛选出状态为2的订单
                    var status2Orders = allOrders.filter(function(order) {
                        return order.status === 2;
                    });
                    
                    appendConsoleLog('筛选出状态为待接单(2)的订单 ' + status2Orders.length + ' 个');
                    
                    if (status2Orders.length === 0) {
                        appendConsoleLog('当前没有待接单状态的订单，10秒后重新获取数据');
                        
                        // 如果没有待接单状态的订单，10秒后重新开始
                        setTimeout(function() {
                            if (isAutoCheckRunning) {
                                autoBatchCheckOrders();
                            }
                        }, 10000);
                        return;
                    }
                    
                    // 开始批量检查
                    appendConsoleLog('开始批量检查订单...');
                    
                    var total = status2Orders.length;
                    var existsCount = 0;  // 存在的订单数
                    var notExistsCount = 0;  // 不存在的订单数
                    var cancelSuccessCount = 0;  // 成功取消的订单数
                    var cancelFailCount = 0;  // 取消失败的订单数
                    var currentIndex = 0;
                    var notExistsOrders = [];
                    var cancelFailOrders = [];
                    
                    /**
                     * 处理下一个订单
                     */
                    function processNextOrder() {
                        if (!isAutoCheckRunning) {
                            // 如果已停止，不再继续处理
                            appendConsoleLog('自动化检查已停止');
                            return;
                        }
                        
                        if (currentIndex >= status2Orders.length) {
                            // 所有订单处理完成
                            var resultMsg = '本轮批量检查完成！\n存在订单：' + existsCount + ' 个\n不存在订单：' + notExistsCount + ' 个\n成功取消：' + cancelSuccessCount + ' 个\n取消失败：' + cancelFailCount + ' 个';
                            if (notExistsOrders.length > 0) {
                                resultMsg += '\n不存在订单：' + notExistsOrders.join(', ');
                            }
                            if (cancelFailOrders.length > 0) {
                                resultMsg += '\n取消失败订单：' + cancelFailOrders.join(', ');
                            }
                            
                            appendConsoleLog(resultMsg);
                            appendConsoleLog('10秒后重新获取最新数据并继续检查...');
                            
                            // 10秒后重新开始整个流程
                            setTimeout(function() {
                                if (isAutoCheckRunning) {
                                    autoBatchCheckOrders();
                                }
                            }, 10000);
                            return;
                        }
                        
                        var order = status2Orders[currentIndex];
                        currentIndex++;
                        
                        appendConsoleLog('检查订单 ' + currentIndex + '/' + total + '：订单ID ' + order.order_id);
                        
                        // 先根据子订单编号查询关联订单
                        getRelatedOrderBySubOrderNo(order.order_id)
                        .then(function(relatedOrder) {
                            // 创建一个新的Promise来确保顺序执行
                            return new Promise(function(resolve) {
                                if (relatedOrder && relatedOrder.sub_orders && relatedOrder.sub_orders.length > 0) {
                                    // 查找代练通的子订单
                                    var dailiantongSubOrder = relatedOrder.sub_orders.find(function(subOrder) {
                                        return subOrder.sub_order_name === '代练通';
                                    });
                                    
                                    if (dailiantongSubOrder) {
                                        // 使用代练通订单ID检查订单是否存在
                                        checkOrderExists(dailiantongSubOrder.sub_order_no)
                                        .then(function(result) {
                                            if (result.exists) {
                                                existsCount++;
                                                appendConsoleLog('✓ 代练通订单存在：' + dailiantongSubOrder.sub_order_no);
                                            } else {
                                                notExistsCount++;
                                                notExistsOrders.push(order.order_id + '(关联代练通订单：' + dailiantongSubOrder.sub_order_no + ')');
                                                appendConsoleLog('✗ 代练通订单不存在：' + dailiantongSubOrder.sub_order_no);
                                                
                                                // 订单不存在，自动取消代练丸子订单
                                                cancelOrder(order.order_id, function(success, orderId, msg) {
                                                    if (success) {
                                                        cancelSuccessCount++;
                                                        appendConsoleLog('✓ 代练丸子订单自动取消成功：' + orderId);
                                                    } else {
                                                        cancelFailCount++;
                                                        cancelFailOrders.push(orderId);
                                                        appendConsoleLog('✗ 代练丸子订单自动取消失败：' + orderId + '，原因：' + msg);
                                                    }
                                                    // 无论取消成功与否，都标记当前订单处理完成
                                                    resolve();
                                                });
                                                return;
                                            }
                                            // 订单存在的情况，标记当前订单处理完成
                                            resolve();
                                        });
                                    } else {
                                        // 未找到关联的代练通订单
                                        notExistsCount++;
                                        notExistsOrders.push(order.order_id + '(未关联代练通订单)');
                                        appendConsoleLog('✗ 未找到关联的代练通订单：' + order.order_id);
                                        // 标记当前订单处理完成
                                        resolve();
                                    }
                                } else {
                                    // 未找到关联订单
                                    notExistsCount++;
                                    notExistsOrders.push(order.order_id + '(未关联任何订单)');
                                    appendConsoleLog('✗ 未找到关联订单：' + order.order_id);
                                    // 标记当前订单处理完成
                                    resolve();
                                }
                            });
                        })
                        .then(function() {
                            // 当前订单处理完成后，等待一段时间再处理下一个订单
                            // 随机等待3-5秒后处理下一个订单
                            var waitTime = 3000 + Math.random() * 2000; // 3000-5000毫秒
                            appendConsoleLog('等待 ' + (waitTime/1000).toFixed(1) + ' 秒后处理下一个订单');
                            
                            setTimeout(processNextOrder, waitTime);
                        })
                        .catch(function(error) {
                            appendConsoleLog('处理订单失败：' + error);
                            
                            // 随机等待3-5秒后处理下一个订单
                            var waitTime = 3000 + Math.random() * 2000; // 3000-5000毫秒
                            setTimeout(processNextOrder, waitTime);
                        });
                    }
                    
                    // 开始处理订单
                    processNextOrder();
                } else {
                    appendConsoleLog('获取订单数据失败：' + (res.data.message || '未知错误'));
                    // 5秒后重试
                    setTimeout(function() {
                        if (isAutoCheckRunning) {
                            autoBatchCheckOrders();
                        }
                    }, 5000);
                }
            })
            .catch(function(error) {
                appendConsoleLog('网络错误，无法获取订单数据：' + error);
                // 5秒后重试
                setTimeout(function() {
                    if (isAutoCheckRunning) {
                        autoBatchCheckOrders();
                    }
                }, 5000);
            });
        }
        
        /**
         * 启动自动化批量检查订单
         */
        function startAutoBatchCheckOrders() {
            // 检查是否已经在运行
            if (isAutoCheckRunning) {
                layer.msg('自动化批量检查功能已经在运行中', {icon: 3});
                return;
            }
            
            // 启动控制台模态框
            startAutoCheckConsoleModal();
            
            // 设置运行状态
            isAutoCheckRunning = true;
            
            appendConsoleLog('自动化批量检查订单功能已启动');
            appendConsoleLog('系统将自动获取所有状态为待接单(2)的订单进行检查');
            appendConsoleLog('完成当前批次检查后，将重新获取最新数据并继续检查');
            
            // 开始执行自动化检查
            autoBatchCheckOrders();
        }
        
        /**
         * 停止自动化批量检查订单
         */
        function stopAutoBatchCheckOrders() {
            // 检查是否在运行
            if (!isAutoCheckRunning) {
                layer.msg('自动化批量检查功能未在运行', {icon: 3});
                return;
            }
            
            // 更新运行状态
            isAutoCheckRunning = false;
            
            // 记录日志
            appendConsoleLog('自动化批量检查功能已停止');
            appendConsoleLog('系统将在2秒后刷新页面以确保所有进程已终止');
            
            // 延迟关闭控制台模态框，让用户有时间看到最后的日志
            setTimeout(function() {
                closeAutoCheckConsoleModal();
                // 2秒后自动刷新页面以强制终止所有进程
                setTimeout(function() {
                    location.reload();
                }, 2000);
            }, 1000);
        }
        
        /**
         * 批量检查订单
         * 实现每3-5秒自动发送一次检查请求的机制，对不存在的订单自动取消
         */
        function batchCheckOrders() {
            // 获取选中的订单
            var checkStatus = table.checkStatus('ID-dailianwanzi-order-table');
            var selectedData = checkStatus.data;
            
            if (selectedData.length === 0) {
                layer.msg('请先选择要检查的订单', {icon: 5});
                return;
            }
            
            // 过滤出符合检查条件的订单（状态为2-待接单或13-待付款）
            var checkableOrders = selectedData.filter(function(order) {
                return order.status === 2 || order.status === 13;
            });
            
            if (checkableOrders.length === 0) {
                layer.msg('选中的订单中没有可检查的订单（只有待接单或待付款状态的订单才能检查）', {icon: 5});
                return;
            }
            
            // 弹出确认框
            layer.confirm('确定要批量检查选中的 ' + checkableOrders.length + ' 个订单吗？\n\n订单不存在将自动取消，订单存在则不执行任何操作。', {
                btn: ['确定', '取消'],
                icon: 3,
                title: '批量检查订单确认'
            }, function(index) {
                layer.close(index);
                
                var total = checkableOrders.length;
                var existsCount = 0;  // 存在的订单数
                var notExistsCount = 0;  // 不存在的订单数
                var cancelSuccessCount = 0;  // 成功取消的订单数
                var cancelFailCount = 0;  // 取消失败的订单数
                var currentIndex = 0;
                var notExistsOrders = [];
                var cancelFailOrders = [];
                
                // 创建进度条弹窗
                var progressIndex = layer.load(2, {
                    shade: [0.3, '#333'],
                    content: '正在检查订单... 0/' + total,
                    success: function(layero) {
                        layero.find('.layui-layer-content').css('padding', '20px');
                    }
                });
                
                /**
                 * 处理下一个订单
                 */
                function processNextOrder() {
                    if (currentIndex >= checkableOrders.length) {
                        // 所有订单处理完成
                        layer.close(progressIndex);
                        
                        var resultMsg = '批量检查订单完成！\n存在订单：' + existsCount + ' 个\n不存在订单：' + notExistsCount + ' 个\n成功取消：' + cancelSuccessCount + ' 个\n取消失败：' + cancelFailCount + ' 个';
                        if (notExistsOrders.length > 0) {
                            resultMsg += '\n不存在订单：' + notExistsOrders.join(', ');
                        }
                        if (cancelFailOrders.length > 0) {
                            resultMsg += '\n取消失败订单：' + cancelFailOrders.join(', ');
                        }
                        
                        layer.alert(resultMsg, {
                            icon: 6,
                            title: '批量检查结果',
                            end: function() {
                                // 弹窗关闭时，关闭所有loading弹层
                                layer.closeAll('loading');
                            }
                        });
                        return;
                    }
                    
                    var order = checkableOrders[currentIndex];
                    currentIndex++;
                    
                    // 更新进度条
                    layer.load(2, {
                        shade: [0.3, '#333'],
                        content: '正在检查订单... ' + (currentIndex - 1) + '/' + total + '\n当前订单ID：' + order.order_id,
                        success: function(layero) {
                            layero.find('.layui-layer-content').css('padding', '20px');
                        }
                    });
                    layer.close(progressIndex);
                    progressIndex = arguments[0];
                    
                    // 先根据子订单编号查询关联订单
                        getRelatedOrderBySubOrderNo(order.order_id)
                        .then(function(relatedOrder) {
                            if (relatedOrder && relatedOrder.sub_orders && relatedOrder.sub_orders.length > 0) {
                                // 查找代练通的子订单
                                var dailiantongSubOrder = relatedOrder.sub_orders.find(function(subOrder) {
                                    return subOrder.sub_order_name === '代练通';
                                });
                                
                                if (dailiantongSubOrder) {
                                    // 使用代练通订单ID检查订单是否存在
                                    checkOrderExists(dailiantongSubOrder.sub_order_no)
                                    .then(function(result) {
                                        if (result.exists) {
                                            existsCount++;
                                            console.log('代练通订单存在：', dailiantongSubOrder.sub_order_no);
                                        } else {
                                            notExistsCount++;
                                            notExistsOrders.push(order.order_id + '(关联代练通订单：' + dailiantongSubOrder.sub_order_no + ')');
                                            console.log('代练通订单不存在：', dailiantongSubOrder.sub_order_no);
                                            
                                            // 订单不存在，自动取消代练丸子订单
                                            cancelOrder(order.order_id, function(success, orderId, msg) {
                                                if (success) {
                                                    cancelSuccessCount++;
                                                    console.log('代练丸子订单自动取消成功：', orderId);
                                                } else {
                                                    cancelFailCount++;
                                                    cancelFailOrders.push(orderId);
                                                    console.log('代练丸子订单自动取消失败：', orderId, msg);
                                                }
                                            });
                                        }
                                    });
                                } else {
                                    // 未找到关联的代练通订单
                                    notExistsCount++;
                                    notExistsOrders.push(order.order_id + '(未关联代练通订单)');
                                    console.log('未找到关联的代练通订单：', order.order_id);
                                }
                            } else {
                                // 未找到关联订单
                                notExistsCount++;
                                notExistsOrders.push(order.order_id + '(未关联任何订单)');
                                console.log('未找到关联订单：', order.order_id);
                            }
                            
                            // 随机等待3-5秒后处理下一个订单
                            var waitTime = 3000 + Math.random() * 2000; // 3000-5000毫秒
                            console.log('等待 ' + (waitTime/1000).toFixed(1) + ' 秒后处理下一个订单');
                            
                            setTimeout(processNextOrder, waitTime);
                        })
                    .catch(function(error) {
                        console.error('处理订单失败：', error);
                        
                        // 随机等待3-5秒后处理下一个订单
                        var waitTime = 3000 + Math.random() * 2000; // 3000-5000毫秒
                        setTimeout(processNextOrder, waitTime);
                    });
                }
                
                // 开始处理订单
                processNextOrder();
            });
        }
        
        // 批量取消订单按钮点击事件
        $('#batchCancelBtn').on('click', function() {
            batchCancelOrders();
        });
        
        // 批量检查订单按钮点击事件
        $('#batchCheckBtn').on('click', function() {
            startAutoBatchCheckOrders();
        });
        
        // 监听表格渲染完成事件，根据订单状态切换按钮显示
        table.on('renderComplete(ID-dailianwanzi-order-table)', function(obj) {
            var rows = obj.cache.data; // 获取当前页数据
            rows.forEach(function(row, index) {
                // 获取当前行的操作按钮元素
                var trElem = $('.layui-table-body tr[data-index="' + index + '"]');
                var cancelBtn = trElem.find('.cancel-order-btn');
                var cannotCancelBtn = trElem.find('.cannot-cancel-btn');
                
                // 根据订单状态切换按钮显示
                if(row.status === 2 || row.status === 13) {
                    cancelBtn.show();
                    cannotCancelBtn.hide();
                } else {
                    cancelBtn.hide();
                    cannotCancelBtn.show();
                }
            });
        });
    });
</script>